/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package agb.Modelo;

import agb.Conexion.Conexion;
import java.sql.*;
import java.util.ArrayList;
import java.util.Vector;
import java.util.Date;

/**
 *
 * @author Administrator
 */
public class Asistencias {
    private int total_asistencia, codPersona;
    private String estado_asistencia,  fecha_asistencia, puntual, tardanzas, faltas, nombrePersona, dia, mes, anio;
    private int inicio;

    public int getInicio() {
        return inicio;
    }

    public void setInicio(int inicio) {
        this.inicio = inicio;
    }
    /**
     * @return the total_asistencia
     */
    public int getTotal_asistencia() {
        return total_asistencia;
    }

    /**
     * @param total_asistencia the total_asistencia to set
     */
    public void setTotal_asistencia(int total_asistencia) {
        this.total_asistencia = total_asistencia;
    }

    /**
     * @return the estado_asistencia
     */
    public String getEstado_asistencia() {
        return estado_asistencia;
    }

    /**
     * @param estado_asistencia the estado_asistencia to set
     */
    public void setEstado_asistencia(String estado_asistencia) {
        this.estado_asistencia = estado_asistencia;
    }

    /**
     * @return the fecha_asistencia
     */
    public String getFecha_asistencia() {
        return fecha_asistencia;
    }

    /**
     * @param fecha_asistencia the fecha_asistencia to set
     */
    public void setFecha_asistencia(String fecha_asistencia) {
        this.fecha_asistencia = fecha_asistencia;
    }

    public static ArrayList<Asistencias> resumenAsistenciaAlumnoPorCodigoFechaDesdeYHasta(int cod_persona, String fechaDesde, String fechaHasta){
        ArrayList<Asistencias> LResumenAsistencia = new ArrayList<Asistencias>();
        Asistencias oAsistencias = null;
        Connection cn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        String sql = "SELECT  COUNT(distinct(to_char(fecha_asistencia,'DDMMYYYY'))) AS total, 'PUNTUAL' AS nombre " +
                     "FROM asistencia a                      " +
                     "WHERE a.cod_persona = ?                      " +//1
                     "AND a.fecha_asistencia BETWEEN to_date(?, 'DD/MM/YYYY') " +//2
                     "AND to_date(?, 'DD/MM/YYYY') " +//3
                     "AND a.estado_asistencia = 'PUNTUAL' " +
                     "UNION                      " +
                     "SELECT  COUNT(distinct(to_char(fecha_asistencia,'DDMMYYYY'))) AS total, 'TARDE' AS nombre  " +
                     "FROM asistencia a                      " +
                     "WHERE a.cod_persona = ?                      " +//4
                     "AND a.fecha_asistencia BETWEEN to_date(?, 'DD/MM/YYYY')                      " +//5
                     "AND to_date(?, 'DD/MM/YYYY')                      " + //6
                     "AND a.estado_asistencia = 'TARDE'                      " +
                     "UNION                      " +
                     "SELECT  COUNT(distinct(to_char(fecha_inasistencia,'DDMMYYYY'))) AS total, 'JUSTIFICACION' AS nombre                      " +
                     "FROM just_inasistencia j                      " +
                     "WHERE cod_persona = ?                      " + //7
                     "AND fecha_inasistencia BETWEEN to_date(?, 'DD/MM/YYYY')                      " + //8
                     "AND to_date(?, 'DD/MM/YYYY')                      " + //9
                     "AND fecha_inasistencia NOT IN (                                    " +
                        "SELECT fecha_asistencia                                    " +
                        "FROM asistencia a                                    " +
                        "WHERE cod_persona = ?                                    " + //10
                        "AND fecha_asistencia BETWEEN to_date(?, 'DD/MM/YYYY')                                    " + //11
                        "AND to_date(?, 'DD/MM/YYYY')                                    )                      " + //12
                     "UNION                      " +
                     "SELECT count(distinct(fecha_falta)) as total, 'FALTA' as nombre                      " +
                     "FROM inasistencia inas                      " +
                     "WHERE cod_persona = ? " + //13
                     "and inas.fecha_falta BETWEEN to_date(?, 'DD/MM/YYYY')                      " + //14
                     "AND to_date(?, 'DD/MM/YYYY')                      " +//15
                     "AND inas.fecha_falta NOT IN (SELECT ji.fecha_inasistencia                                                  " +
                        "FROM just_inasistencia ji                                                  " +
                        "WHERE ji.cod_persona = ?                                                  " + //16
                        "AND ji.fecha_inasistencia BETWEEN to_date(?, 'DD/MM/YYYY')                                                  " + //17
                        "AND to_date(?, 'DD/MM/YYYY'))" ;  //18
        try{
            cn = Conexion.getConexion();
            ps = cn.prepareStatement(sql);
            ps.setInt(1, cod_persona);
            ps.setString(2, fechaDesde);
            ps.setString(3, fechaHasta);
            ps.setInt(4, cod_persona);
            ps.setString(5, fechaDesde);
            ps.setString(6, fechaHasta);
            ps.setInt(7, cod_persona);
            ps.setString(8, fechaDesde);
            ps.setString(9, fechaHasta);
            ps.setInt(10, cod_persona);
            ps.setString(11, fechaDesde);
            ps.setString(12, fechaHasta);
            ps.setInt(13, cod_persona);
            ps.setString(14, fechaDesde);
            ps.setString(15, fechaHasta);
            ps.setInt(16, cod_persona);
            ps.setString(17, fechaDesde);
            ps.setString(18, fechaHasta);//MEJOR UTILIZAR PROCEDIMIENTOS ALMACENADOS (FUNCIONES)
            rs = ps.executeQuery();
            while(rs.next()){
                oAsistencias = new Asistencias();
                oAsistencias.setTotal_asistencia(rs.getInt(1));
                oAsistencias.setEstado_asistencia(rs.getString(2));
                LResumenAsistencia.add(oAsistencias);
            }
        Conexion.cerrarPreparedStatement(ps);
        Conexion.cerrarConexion(cn);
        }catch(SQLException ex){
            ex.printStackTrace();
            Conexion.cerrarPreparedStatement(ps);
            Conexion.cerrarConexion(cn);
        }catch(Exception ex){
            ex.printStackTrace();
        }
        return LResumenAsistencia;
    }

      public ArrayList<Asistencias> listaAsistenciaAlumnoPorCodigoFechaDesdeYHasta(int cod_persona, String fechaDesde, String fechaHasta){
        ArrayList<Asistencias> LResumenAsistencia = new ArrayList<Asistencias>();
        Asistencias oAsistencias = null;
        Connection cn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        String sql = "SELECT F.FECHA, F.NOMBRE " +
                    "FROM( " +
                    "SELECT  distinct(to_char(fecha_asistencia,'DD/MM/YYYY')) AS FECHA, 'puntual' AS nombre " +
                    "FROM asistencia a " +
                    "WHERE a.cod_persona = ?       " +
                    "AND a.fecha_asistencia BETWEEN to_date(?, 'DD/MM/YYYY')       " +
                    "AND to_date(?, 'DD/MM/YYYY')       " +
                    "AND a.estado_asistencia = 'PUNTUAL' " +
                    "UNION " +
                    "SELECT  distinct(to_char(fecha_asistencia,'DD/MM/YYYY')) AS FECHA, 'tarde' AS nombre " +
                    "FROM asistencia a " +
                    "WHERE a.cod_persona = ?       " +
                    "AND a.fecha_asistencia BETWEEN to_date(?, 'DD/MM/YYYY')       " +
                    "AND to_date(?, 'DD/MM/YYYY')       " +
                    "AND a.estado_asistencia = 'TARDE' " +
                    "UNION " +
                    "SELECT  distinct(to_char(fecha_inasistencia,'DD/MM/YYYY')) AS FECHA, 'justificacion' AS nombre " +
                    "FROM just_inasistencia j " +
                    "WHERE cod_persona = ?       " +
                    "AND fecha_inasistencia BETWEEN to_date(?, 'DD/MM/YYYY')       " +
                    "AND to_date(?, 'DD/MM/YYYY')       " +
                    "AND fecha_inasistencia NOT IN (           " +
                        "SELECT fecha_asistencia           " +
                        "FROM asistencia a           " +
                        "WHERE cod_persona = ?           " +
                        "AND fecha_asistencia BETWEEN to_date(?, 'DD/MM/YYYY')           " +
                        "AND to_date(?, 'DD/MM/YYYY')) " +
                    "UNION " +
                    "SELECT distinct(to_char(fecha_falta,'DD/MM/YYYY')) AS FECHA, 'falta' as nombre " +
                    "FROM inasistencia inas " +
                    "WHERE cod_persona = ? " +
                    "and inas.fecha_falta BETWEEN to_date(?, 'DD/MM/YYYY')       " +
                    "AND to_date(?, 'DD/MM/YYYY')       " +
                    "AND inas.fecha_falta NOT IN (" +
                        "SELECT ji.fecha_inasistencia           " +
                        "FROM just_inasistencia ji           " +
                        "WHERE cod_persona = ?           " +
                        "AND  ji.fecha_inasistencia BETWEEN to_date(?, 'DD/MM/YYYY')           " +
                        "AND to_date(?, 'DD/MM/YYYY')) " +
                  ") AS F " +
                  "ORDER BY to_date(F.FECHA, 'DD/MM/YYYY') " ;  //18
        try{
            cn = Conexion.getConexion();
            ps = cn.prepareStatement(sql);
            ps.setInt(1, cod_persona);
            ps.setString(2, fechaDesde);
            ps.setString(3, fechaHasta);
            ps.setInt(4, cod_persona);
            ps.setString(5, fechaDesde);
            ps.setString(6, fechaHasta);
            ps.setInt(7, cod_persona);
            ps.setString(8, fechaDesde);
            ps.setString(9, fechaHasta);
            ps.setInt(10, cod_persona);
            ps.setString(11, fechaDesde);
            ps.setString(12, fechaHasta);
            ps.setInt(13, cod_persona);
            ps.setString(14, fechaDesde);
            ps.setString(15, fechaHasta);
            ps.setInt(16, cod_persona);
            ps.setString(17, fechaDesde);
            ps.setString(18, fechaHasta);//MEJOR UTILIZAR PROCEDIMIENTOS ALMACENADOS (FUNCIONES)
            rs = ps.executeQuery();
            while(rs.next()){
                oAsistencias = new Asistencias();
                oAsistencias.setFecha_asistencia(rs.getString(1));
                oAsistencias.setEstado_asistencia(rs.getString(2));
                LResumenAsistencia.add(oAsistencias);
            }
        Conexion.cerrarPreparedStatement(ps);
        Conexion.cerrarConexion(cn);
        }catch(SQLException ex){
            ex.printStackTrace();
            Conexion.cerrarPreparedStatement(ps);
            Conexion.cerrarConexion(cn);
        }catch(Exception ex){
            ex.printStackTrace();
        }
        return LResumenAsistencia;
    }


      public Vector<Asistencias> listaAsistenciaDocenteBloquePorCodigoFechaDesdeYHasta(int cod_persona, String fechaDesde, String fechaHasta){
        Vector<Asistencias> LResumenAsistencia = new Vector<Asistencias>();
        Asistencias oAsistencias = null;
        Connection cn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        String sql = "SELECT F.FECHA, F.NOMBRE, F.BLOQUE " +
                "FROM( " +
                    "SELECT  to_char(fecha_asistencia,'DD/MM/YYYY') AS FECHA, 'puntual' AS nombre, a.nro_bloque as BLOQUE " +
                    "FROM asistencia a  " +
                    "WHERE a.cod_persona = ?       " +
                    "AND a.fecha_asistencia BETWEEN to_date(?, 'DD/MM/YYYY')       " +
                    "AND to_date(?, 'DD/MM/YYYY')       " +
                    "AND a.estado_asistencia = 'PUNTUAL' " +
                    "UNION " +
                    "SELECT  to_char(fecha_asistencia,'DD/MM/YYYY') AS FECHA, 'tarde' AS nombre,a.nro_bloque as BLOQUE " +
                    "FROM asistencia a " +
                    "WHERE a.cod_persona = ?       " +
                    "AND a.fecha_asistencia BETWEEN to_date(?, 'DD/MM/YYYY')       " +
                    "AND to_date(?, 'DD/MM/YYYY')       " +
                    "AND a.estado_asistencia = 'TARDE' " +
                    "UNION " +
                    "SELECT  to_char(fecha_inasistencia,'DD/MM/YYYY') AS FECHA, 'justificacion' AS nombre, j.nrobloque  as BLOQUE " +
                    "FROM just_inasistencia j " +
                    "WHERE cod_persona = ?       " +
                    "AND fecha_inasistencia BETWEEN to_date(?, 'DD/MM/YYYY')       " +
                    "AND to_date(?, 'DD/MM/YYYY')       " +
                    "AND fecha_inasistencia NOT IN (           " +
                        "SELECT fecha_asistencia           " +
                        "FROM asistencia a           " +
                        "WHERE cod_persona = ?           " +
                        "AND fecha_asistencia BETWEEN to_date(?, 'DD/MM/YYYY')           " +
                        "AND to_date(?, 'DD/MM/YYYY')) " +
                     "UNION " +
                     "SELECT to_char(fecha_falta,'DD/MM/YYYY') AS FECHA, 'falta' as nombre, inas.nro_bloque as BLOQUE " +
                     "FROM inasistencia inas " +
                     "WHERE cod_persona = ?  " +
                     "and inas.fecha_falta BETWEEN to_date(?, 'DD/MM/YYYY')       " +
                     "AND to_date(?, 'DD/MM/YYYY')       " +
                     "AND inas.fecha_falta NOT IN (" +
                        "SELECT ji.fecha_inasistencia           " +
                        "FROM just_inasistencia ji           " +
                        "WHERE cod_persona = ?           " +
                        "AND  ji.fecha_inasistencia BETWEEN to_date(?, 'DD/MM/YYYY')           " +
                        "AND to_date(?, 'DD/MM/YYYY')) ) AS F " +
                 "ORDER BY to_date(F.FECHA, 'DD/MM/YYYY'), F.BLOQUE " ;  //18
        try{
            cn = Conexion.getConexion();
            ps = cn.prepareStatement(sql);
            ps.setInt(1, cod_persona);
            ps.setString(2, fechaDesde);
            ps.setString(3, fechaHasta);
            ps.setInt(4, cod_persona);
            ps.setString(5, fechaDesde);
            ps.setString(6, fechaHasta);
            ps.setInt(7, cod_persona);
            ps.setString(8, fechaDesde);
            ps.setString(9, fechaHasta);
            ps.setInt(10, cod_persona);
            ps.setString(11, fechaDesde);
            ps.setString(12, fechaHasta);
            ps.setInt(13, cod_persona);
            ps.setString(14, fechaDesde);
            ps.setString(15, fechaHasta);
            ps.setInt(16, cod_persona);
            ps.setString(17, fechaDesde);
            ps.setString(18, fechaHasta);//MEJOR UTILIZAR PROCEDIMIENTOS ALMACENADOS (FUNCIONES)
            rs = ps.executeQuery();
            while(rs.next()){
                oAsistencias = new Asistencias();
                oAsistencias.setFecha_asistencia(rs.getString(1));
                oAsistencias.setEstado_asistencia(rs.getString(2));
                LResumenAsistencia.add(oAsistencias);
            }
        Conexion.cerrarPreparedStatement(ps);
        Conexion.cerrarConexion(cn);
        }catch(SQLException ex){
            ex.printStackTrace();
            Conexion.cerrarPreparedStatement(ps);
            Conexion.cerrarConexion(cn);
        }catch(Exception ex){
            ex.printStackTrace();
        }
        return LResumenAsistencia;
    }

      public Vector<Asistencias> listaAsistenciaDocentePorCodigoFechaDesdeYHasta(int cod_persona, String fechaDesde, String fechaHasta){
        Vector<Asistencias> LResumenAsistencia = new Vector<Asistencias>();
        Asistencias oAsistencias = null;
        Connection cn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        String sql = "select a.fecha_asistencia, a.estado_asistencia " +
                "from asistencia a " +
                "where a.cod_persona = ? and a.fecha_asistencia between to_date(?, 'dd/mm/yyyy') and to_date(?, 'dd/mm/yyyy') order by a.fecha_asistencia";
        try{
            cn = Conexion.getConexion();
            ps = cn.prepareStatement(sql);
            ps.setInt(1, cod_persona);
            ps.setString(2, fechaDesde);
            ps.setString(3, fechaHasta);
           rs = ps.executeQuery();
            while(rs.next()){
                oAsistencias = new Asistencias();
                oAsistencias.setFecha_asistencia(rs.getString(1));
                oAsistencias.setEstado_asistencia(rs.getString(2));
                LResumenAsistencia.add(oAsistencias);
            }
        Conexion.cerrarPreparedStatement(ps);
        Conexion.cerrarConexion(cn);
        }catch(SQLException ex){
            ex.printStackTrace();
            Conexion.cerrarPreparedStatement(ps);
            Conexion.cerrarConexion(cn);
        }catch(Exception ex){
            ex.printStackTrace();
        }
        return LResumenAsistencia;
    }

    public static Vector<Asistencias> detalleAsistenciasPuntualAlumnoPorCodigoFechaDesdeYHasta(int cod_persona, String fechaDesde, String fechaHasta){
        Vector<Asistencias> LResumenAsistencia = new Vector<Asistencias>();
        Asistencias oAsistencias = null;
        Connection cn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        String sql = "select distinct(to_char(fecha_asistencia,'DD/MM/YYYY')),'PUNTUAL' AS nombre " +
                     "from asistencia " +
                     "where cod_persona = ? and fecha_asistencia BETWEEN to_date(?, 'DD/MM/YYYY')                      " +
                     "AND to_date(?, 'DD/MM/YYYY')" ;
        try{
            cn = Conexion.getConexion();
            ps = cn.prepareStatement(sql);
            ps.setInt(1, cod_persona);
            ps.setString(2, fechaDesde);
            ps.setString(3, fechaHasta);
            rs = ps.executeQuery();
            while(rs.next()){
                oAsistencias = new Asistencias();
                oAsistencias.setFecha_asistencia(rs.getString(1));
                oAsistencias.setEstado_asistencia(rs.getString(2));
                LResumenAsistencia.add(oAsistencias);
            }
        Conexion.cerrarPreparedStatement(ps);
        Conexion.cerrarConexion(cn);
        }catch(SQLException ex){
            ex.printStackTrace();
            Conexion.cerrarPreparedStatement(ps);
            Conexion.cerrarConexion(cn);
        }catch(Exception ex){
            ex.printStackTrace();
        }
        return LResumenAsistencia;
    }

    public static boolean asistenciaPuntualPorFecha(int cod_persona, String fecha){        
        boolean rpta = false;
        Connection cn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        String sql = "select a.estado_asistencia " +
                "from asistencia a " +
                "where a.cod_persona = ? " +
                "and a.fecha_asistencia = to_date(?, 'dd/mm/yyyy') " +
                " and a.estado_asistencia = 'PUNTUAL' " +
                "order by a.fecha_asistencia";

        try{
            cn = Conexion.getConexion();
            ps = cn.prepareStatement(sql);
            ps.setInt(1, cod_persona);
            ps.setString(2, fecha);

            rs = ps.executeQuery();
            while(rs.next()){
                rpta = true;
            }
        Conexion.cerrarPreparedStatement(ps);
        Conexion.cerrarConexion(cn);
        }catch(SQLException ex){
            ex.printStackTrace();
            Conexion.cerrarPreparedStatement(ps);
            Conexion.cerrarConexion(cn);
        }catch(Exception ex){
            ex.printStackTrace();
        }
        return rpta;
    }
    
    public static boolean asistenciaTardePorFecha(int cod_persona, String fecha){        
        boolean rpta = false;
        Connection cn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        String sql = "select a.estado_asistencia " +
                "from asistencia a " +
                "where a.cod_persona = ? " +
                "and a.fecha_asistencia = to_date(?, 'dd/mm/yyyy') " +
                 " and a.estado_asistencia = 'TARDE' " +
                "order by a.fecha_asistencia";

        try{
            cn = Conexion.getConexion();
            ps = cn.prepareStatement(sql);
            ps.setInt(1, cod_persona);
            ps.setString(2, fecha);

            rs = ps.executeQuery();
            while(rs.next()){
                rpta = true;
            }
        Conexion.cerrarPreparedStatement(ps);
        Conexion.cerrarConexion(cn);
        }catch(SQLException ex){
            ex.printStackTrace();
            Conexion.cerrarPreparedStatement(ps);
            Conexion.cerrarConexion(cn);
        }catch(Exception ex){
            ex.printStackTrace();
        }
        return rpta;
    }

    public static boolean asistenciaJustificacionPorFecha(int cod_persona, String fecha){
        boolean rpta = false;
        Connection cn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        String sql = "SELECT  distinct(to_char(fecha_inasistencia,'DDMMYYYY')) AS total  " +
                "FROM just_inasistencia j " +
                "WHERE cod_persona = ? " +
                "AND fecha_inasistencia = to_date(?, 'DD/MM/YYYY') " +
                "AND fecha_inasistencia NOT IN ( " +
                    "SELECT fecha_asistencia " +
                    "FROM asistencia a " +
                    "WHERE cod_persona = ? " +
                    "AND fecha_asistencia = to_date(?, 'DD/MM/YYYY')) " ;


        try{
            cn = Conexion.getConexion();
            ps = cn.prepareStatement(sql);
            ps.setInt(1, cod_persona);
            ps.setString(2, fecha);
            ps.setInt(3, cod_persona);
            ps.setString(4, fecha);

            rs = ps.executeQuery();
            while(rs.next()){
                rpta = true;
            }
        Conexion.cerrarPreparedStatement(ps);
        Conexion.cerrarConexion(cn);
        }catch(SQLException ex){
            ex.printStackTrace();
            Conexion.cerrarPreparedStatement(ps);
            Conexion.cerrarConexion(cn);
        }catch(Exception ex){
            ex.printStackTrace();
        }
        return rpta;
    }


      public static int verificaSabadoDomingo(String fecha){
        int rpta = 0;
        Connection cn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        String sql = "select date_part('dow',to_date(?, 'dd/mm/yyyy'));";

        try{
            cn = Conexion.getConexion();
            ps = cn.prepareStatement(sql);
            ps.setString(1, fecha);

            rs = ps.executeQuery();
            while(rs.next()){
                rpta = rs.getInt(1);
            }
        Conexion.cerrarPreparedStatement(ps);
        Conexion.cerrarConexion(cn);
        }catch(SQLException ex){
            ex.printStackTrace();
            Conexion.cerrarPreparedStatement(ps);
            Conexion.cerrarConexion(cn);
        }catch(Exception ex){
            ex.printStackTrace();
        }
        return rpta;
    }



    public static Vector<Asistencias> detalleAsistenciasTardeAlumnoPorCodigoFechaDesdeYHasta(int cod_persona, String fechaDesde, String fechaHasta){
        Vector<Asistencias> LResumenAsistencia = new Vector<Asistencias>();
        Asistencias oAsistencias = null;
        Connection cn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        String sql = "SELECT  distinct(to_char(fecha_asistencia,'DD/MM/YYYY')) AS total, 'TARDE' AS nombre                      " +
                "FROM asistencia a                      " +
                "WHERE a.cod_persona = ?                      " +
                "AND a.fecha_asistencia BETWEEN to_date(?, 'DD/MM/YYYY')                      " +
                "AND to_date(?, 'DD/MM/YYYY')                      " +
                "AND a.estado_asistencia = 'TARDE'" ;
        try{
            cn = Conexion.getConexion();
            ps = cn.prepareStatement(sql);
            ps.setInt(1, cod_persona);
            ps.setString(2, fechaDesde);
            ps.setString(3, fechaHasta);
            rs = ps.executeQuery();
            while(rs.next()){
                oAsistencias = new Asistencias();
                oAsistencias.setFecha_asistencia(rs.getString(1));
                oAsistencias.setEstado_asistencia(rs.getString(2));
                LResumenAsistencia.add(oAsistencias);
            }
        Conexion.cerrarPreparedStatement(ps);
        Conexion.cerrarConexion(cn);
        }catch(SQLException ex){
            ex.printStackTrace();
            Conexion.cerrarPreparedStatement(ps);
            Conexion.cerrarConexion(cn);
        }catch(Exception ex){
            ex.printStackTrace();
        }
        return LResumenAsistencia;
    }

       public static Vector<Asistencias> detalleAsistenciasJustificacionAlumnoPorCodigoFechaDesdeYHasta(int cod_persona, String fechaDesde, String fechaHasta){
        Vector<Asistencias> LResumenAsistencia = new Vector<Asistencias>();
        Asistencias oAsistencias = null;
        Connection cn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        String sql = "SELECT  distinct(to_char(fecha_inasistencia,'DDMMYYYY')) AS total, 'JUSTIFICACION' AS nombre   " +
                "FROM just_inasistencia j " +
                "WHERE cod_persona = ? " +
                "AND fecha_inasistencia BETWEEN to_date(?, 'DD/MM/YYYY') " +
                "AND to_date(?, 'DD/MM/YYYY') " +
                "AND fecha_inasistencia NOT IN ( " +
                    "SELECT fecha_asistencia " +
                    "FROM asistencia a " +
                    "WHERE cod_persona = ? " +
                    "AND fecha_asistencia BETWEEN to_date(?, 'DD/MM/YYYY')" +
                    "AND to_date(?, 'DD/MM/YYYY'))" ;
        try{
            cn = Conexion.getConexion();
            ps = cn.prepareStatement(sql);
            ps.setInt(1, cod_persona);
            ps.setString(2, fechaDesde);
            ps.setString(3, fechaHasta);
            ps.setInt(4, cod_persona);
            ps.setString(5, fechaDesde);
            ps.setString(6, fechaHasta);
            rs = ps.executeQuery();
            while(rs.next()){
                oAsistencias = new Asistencias();
                oAsistencias.setFecha_asistencia(rs.getString(1));
                oAsistencias.setEstado_asistencia(rs.getString(2));
                LResumenAsistencia.add(oAsistencias);
            }
        Conexion.cerrarPreparedStatement(ps);
        Conexion.cerrarConexion(cn);
        }catch(SQLException ex){
            ex.printStackTrace();
            Conexion.cerrarPreparedStatement(ps);
            Conexion.cerrarConexion(cn);
        }catch(Exception ex){
            ex.printStackTrace();
        }
        return LResumenAsistencia;
    }

       public static Vector<Asistencias> detalleAsistenciasFaltasAlumnoPorCodigoFechaDesdeYHasta(int cod_persona, String fechaDesde, String fechaHasta){
        Vector<Asistencias> LResumenAsistencia = new Vector<Asistencias>();
        Asistencias oAsistencias = null;
        Connection cn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        String sql = "SELECT distinct(fecha_falta) as total, 'FALTA' as nombre                      " +
                     "FROM inasistencia inas                      " +
                     "WHERE cod_persona = ? " +
                     "and inas.fecha_falta BETWEEN to_date(?, 'DD/MM/YYYY')                      " +
                     "AND to_date(?, 'DD/MM/YYYY')                      " +
                     "AND inas.fecha_falta NOT IN (SELECT ji.fecha_inasistencia                                                  " +
                        "FROM just_inasistencia ji                                                  " +
                        "WHERE ji.cod_persona = ?                                                  " +
                        "AND ji.fecha_inasistencia BETWEEN to_date(?, 'DD/MM/YYYY')                                                  " +
                        "AND to_date(?, 'DD/MM/YYYY'))" ;
        try{
            cn = Conexion.getConexion();
            ps = cn.prepareStatement(sql);
            ps.setInt(1, cod_persona);
            ps.setString(2, fechaDesde);
            ps.setString(3, fechaHasta);
            ps.setInt(4, cod_persona);
            ps.setString(5, fechaDesde);
            ps.setString(6, fechaHasta);
            rs = ps.executeQuery();
            while(rs.next()){
                oAsistencias = new Asistencias();
                oAsistencias.setFecha_asistencia(rs.getString(1));
                oAsistencias.setEstado_asistencia(rs.getString(2));
                LResumenAsistencia.add(oAsistencias);
            }
        Conexion.cerrarPreparedStatement(ps);
        Conexion.cerrarConexion(cn);
        }catch(SQLException ex){
            ex.printStackTrace();
            Conexion.cerrarPreparedStatement(ps);
            Conexion.cerrarConexion(cn);
        }catch(Exception ex){
            ex.printStackTrace();
        }
        return LResumenAsistencia;
    }

    /**
     * @return the puntual
     */
    public String getPuntual() {
        return puntual;
    }

    /**
     * @param puntual the puntual to set
     */
    public void setPuntual(String puntual) {
        this.puntual = puntual;
    }

    /**
     * @return the tardanzas
     */
    public String getTardanzas() {
        return tardanzas;
    }

    /**
     * @param tardanzas the tardanzas to set
     */
    public void setTardanzas(String tardanzas) {
        this.tardanzas = tardanzas;
    }

    /**
     * @return the faltas
     */
    public String getFaltas() {
        return faltas;
    }

    /**
     * @param faltas the faltas to set
     */
    public void setFaltas(String faltas) {
        this.faltas = faltas;
    }

    /**
     * @return the nombrePersona
     */
    public String getNombrePersona() {
        return nombrePersona;
    }

    /**
     * @param nombrePersona the nombrePersona to set
     */
    public void setNombrePersona(String nombrePersona) {
        this.nombrePersona = nombrePersona;
    }

        public static Vector<Asistencias> resumenAsistenciaAulas(int codGrado, int codSeccion, int codNivel, String fechaDesde, String fechaHasta) {
        Vector<Asistencias> LAlumnos = new Vector<Asistencias>();
        Asistencias oAsistencia = null;
        Date fecha = new Date();
        Connection cn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        String sql = "select distinct pn.apell_paterno || ' ' || pn.apell_materno || ',  '|| pn.primer_nombre as nombre, pn.cod_persona, " +
                "( SELECT COUNT(distinct(to_char(fecha_asistencia,'DDMMYYYY'))) AS total " +
                    "FROM asistencia a  " +
                    "WHERE a.cod_persona = pn.cod_persona " +
                    "AND a.fecha_asistencia BETWEEN to_date(?, 'DD/MM/YYYY')  AND to_date(?, 'DD/MM/YYYY') " +
                    "AND a.estado_asistencia = 'PUNTUAL') as PUNTUAL, " +
                 "(SELECT COUNT(distinct(to_char(fecha_asistencia,'DDMMYYYY'))) AS total " +
                    "FROM asistencia a " +
                    "WHERE a.cod_persona = pn.cod_persona " +
                    "AND a.fecha_asistencia BETWEEN to_date(?, 'DD/MM/YYYY')  AND to_date(?, 'DD/MM/YYYY') " +
                    "AND a.estado_asistencia = 'TARDE') as TARDANZA, " +
                 "(SELECT count(distinct(fecha_falta)) as total " +
                    "FROM inasistencia inas  " +
                    "WHERE inas.cod_persona = pn.cod_persona " +
                    "and inas.fecha_falta BETWEEN to_date(?, 'DD/MM/YYYY')  AND to_date(?, 'DD/MM/YYYY') " +
                    "AND inas.fecha_falta NOT IN (" +
                        "SELECT ji.fecha_inasistencia     " +
                        "FROM just_inasistencia ji     " +
                        "WHERE ji.cod_persona = pn.cod_persona     " +
                        "AND ji.fecha_inasistencia BETWEEN to_date(?, 'DD/MM/YYYY')  AND to_date(?, 'DD/MM/YYYY'))) as faltas, al.cod_alumno " +
                 "from matricula m " +
                 "inner join p_natural pn on pn.cod_persona = m.cod_persona " +
                 "inner join aula a on m.cod_aula = a.cod_aula " +
                 "inner join programacion_aula pa on pa.cod_progaula = m.cod_progaula " +
                 "inner join nivel_grado ng on pa.cod_nivelgrado = ng.cod_nivelgrado " +
                 "inner join nivel n on n.cod_nivel = ng.cod_nivel " +
                 "inner join grado g on g.cod_grado = ng.cod_grado " +
                 "inner join alumno al on al.cod_persona = pn.cod_persona " +
                 "where g.cod_grado = ? " +
                 "and a.cod_aula = ? " +
                 "and n.cod_nivel =? " +
                 "and TO_CHAR(m.fecha_registro, 'YYYY') = " + (fecha.getYear() + 1900) +
                 "and m.estado_actividad = true ;";
        try {
            cn = Conexion.getConexion();
            ps = cn.prepareStatement(sql);
            ps.setString(1, fechaDesde);
            ps.setString(2, fechaHasta);
            ps.setString(3, fechaDesde);
            ps.setString(4, fechaHasta);
            ps.setString(5, fechaDesde);
            ps.setString(6, fechaHasta);
            ps.setString(7, fechaDesde);
            ps.setString(8, fechaHasta);
            ps.setInt(9, codGrado);
            ps.setInt(10, codSeccion);
            ps.setInt(11, codNivel);
            rs = ps.executeQuery();
            while (rs.next()) {
                oAsistencia = new Asistencias();

                oAsistencia.setNombrePersona(rs.getString(1));
                oAsistencia.setCodPersona(rs.getInt(2));
                oAsistencia.setPuntual(rs.getString(3));
                oAsistencia.setTardanzas(rs.getString(4));
                oAsistencia.setFaltas(rs.getString(5));
                oAsistencia.setEstado_asistencia(rs.getString(6));
                LAlumnos.add(oAsistencia);
            }
        Conexion.cerrarPreparedStatement(ps);
        Conexion.cerrarConexion(cn);
        } catch (SQLException ex) {
            ex.printStackTrace();
            Conexion.cerrarPreparedStatement(ps);
            Conexion.cerrarConexion(cn);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return LAlumnos;
    }

    /**
     * @return the codPersona
     */
    public int getCodPersona() {
        return codPersona;
    }

    /**
     * @param codPersona the codPersona to set
     */
    public void setCodPersona(int codPersona) {
        this.codPersona = codPersona;
    }

    /**
     * @return the dia
     */
    public String getDia() {
        return dia;
    }

    /**
     * @param dia the dia to set
     */
    public void setDia(String dia) {
        this.dia = dia;
    }

    /**
     * @return the mes
     */
    public String getMes() {
        return mes;
    }

    /**
     * @param mes the mes to set
     */
    public void setMes(String mes) {
        this.mes = mes;
    }

    /**
     * @return the anio
     */
    public String getAnio() {
        return anio;
    }

    /**
     * @param anio the anio to set
     */
    public void setAnio(String anio) {
        this.anio = anio;
    }

}
